// import { reject, resolve } from "core-js/fn/promise"

console.log("xxxx")

// let arr1 = [1,2,3,4,5,7]
// let arr2 = [3,4,5,6,8,9,10]

// function merge(arr1, arr2) {

//     while(arr1.length){
//         let number = arr1.shift()
//         let i = 0
//         let pre = null
//         while(i<arr2.length){
//             if((pre===null || number>pre) && number<=arr2[i]){
//                 arr2.splice(i, 0, number)
//                 break
//             }
//             pre = arr2[i]
//             i++
//         }
//     }

//     return arr2
// }

// console.log(merge(arr1, arr2))



// 输入一个字符串，输入保证无重复字符，取n个排列的结果
// 函数会打印字符串排列，无需考虑顺序
// pailie
function printFullArray(str, n) {
    let arr = str.split("")
    let i = 0

    const printWord = (num, arr, i) => {
        if (arr.length > 0 && i++ < n) {
            arr.map((w, index) => {
                printWord(num + w, arr.filter(number => number !== w), i)
            })
        } else {
            console.log(num)
        }
    }

    printWord("", arr, i)
}

// 例：
// printFullArray('123', 3);

// 打印结果如下
// 123
// 132
// 213
// 231
// 312
// 321

// printFullArray('123', 2);

// 打印结果如下
// 12
// 13
// 21
// 23
// 32
// 31






/**
 * 提供一个异步执行调度方法
 * 该方法需要具备：
 *   1. 当调用执行方法 on，会按照 *调用的先后顺序* 执行回调 onSuccess
 *   2. （可选实现能力）执行方法 on 在调用后，会返回一个 cancel 句柄，执行后，*无论异步方法执行成功或者失败* 都不响应
 *   3. （可选实现能力）超时时间 3秒，超时需要返回 TimeoutError，并且不再响应其他状态
 */
// interface IAsyncScheduler {
//     on(promise: PromiseLike<any>, onSuccess?: Function, onError?: Function): () => void;
// }

// 根据题干描述要求，完成该类的实现，可以任意定义成员
class AsyncScheduler {
    constructor() {
        this.task = []
        this.isReady = true
    }

    on = (promise, onSuccess, onError) => {
        let cancel = false
        // TODO impl
        this.task.push(()=> {
            if(cancel) return

            let timeout = false
            let timer = setTimeout(() => {
                timeout = true
            }, 3000)


            let p = promise()
            p.then(value => {
                if(timeout){
                    throw new Error("TimeoutError")
                    return
                }
                clearTimeout(timer)
                onSuccess(value)

            }, error => {
                if(timeout){
                    throw new Error("TimeoutError")
                    return
                }
                clearTimeout(timer)
                onError(error)
            })

            return p
        })

        this.isReady && this.excuteTask()

        return function () {
            cancel = true
        }
    }

    excuteTask = () => {
        if(this.task.length > 0){
            this.isReady = false

            let task = this.task.shift()
            let taskPromise = task()
            taskPromise && taskPromise.then(()=>{
                this.excuteTask()
            })
        } else{
            this.isReady = true 
        }
    }
}




// 以下是 Demo 代码
// 模拟一个耗时的异步
const delay = (wait) => {
    return function () {
        return new Promise ((resolve) => {
            setTimeout(() => resolve(0), wait)
        })
    }
};

const scheduler = new AsyncScheduler();

// 模拟1秒的异步
const cancel1 = scheduler.on(
    delay(1000),
    () => console.log(1),
    (err) => console.error(err),
);

// 模拟0.5秒的异步
const cancel2 = scheduler.on(
    delay(500),
    () => console.log(2),
    (err) => console.error(err),
);

// 模拟超时
const cancel3 = scheduler.on(
    delay(4000),
    () => console.log(3),
    (err) => console.error(err),
);

// cancel3()
// 期望执行打印结果顺序：1 2 TimeoutError 的异常日志
// 1秒内执行 cancel1() 的执行结果 2 TimeoutError 的异常日志
// 0.5秒内执行 cancel2() 的执行结果 1 TimeoutError 的异常日志
// 3秒内执行 cancel3() 的执行结果 1 2

